<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <title>tf::ScalablePipeline class | Taskflow QuickStart</title>
  <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Source+Sans+Pro:400,400i,600,600i%7CSource+Code+Pro:400,400i,600" />
  <link rel="stylesheet" href="m-dark+documentation.compiled.css" />
  <link rel="icon" href="favicon.ico" type="image/vnd.microsoft.icon" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <meta name="theme-color" content="#22272e" />
</head>
<body>
<header><nav id="navigation">
  <div class="m-container">
    <div class="m-row">
      <span id="m-navbar-brand" class="m-col-t-8 m-col-m-none m-left-m">
        <a href="https://taskflow.github.io"><img src="taskflow_logo.png" alt="" />Taskflow</a> <span class="m-breadcrumb">|</span> <a href="index.html" class="m-thin">QuickStart</a>
      </span>
      <div class="m-col-t-4 m-hide-m m-text-right m-nopadr">
        <a href="#search" class="m-doc-search-icon" title="Search" onclick="return showSearch()"><svg style="height: 0.9rem;" viewBox="0 0 16 16">
          <path id="m-doc-search-icon-path" d="m6 0c-3.31 0-6 2.69-6 6 0 3.31 2.69 6 6 6 1.49 0 2.85-0.541 3.89-1.44-0.0164 0.338 0.147 0.759 0.5 1.15l3.22 3.79c0.552 0.614 1.45 0.665 2 0.115 0.55-0.55 0.499-1.45-0.115-2l-3.79-3.22c-0.392-0.353-0.812-0.515-1.15-0.5 0.895-1.05 1.44-2.41 1.44-3.89 0-3.31-2.69-6-6-6zm0 1.56a4.44 4.44 0 0 1 4.44 4.44 4.44 4.44 0 0 1-4.44 4.44 4.44 4.44 0 0 1-4.44-4.44 4.44 4.44 0 0 1 4.44-4.44z"/>
        </svg></a>
        <a id="m-navbar-show" href="#navigation" title="Show navigation"></a>
        <a id="m-navbar-hide" href="#" title="Hide navigation"></a>
      </div>
      <div id="m-navbar-collapse" class="m-col-t-12 m-show-m m-col-m-none m-right-m">
        <div class="m-row">
          <ol class="m-col-t-6 m-col-m-none">
            <li><a href="pages.html">Handbook</a></li>
            <li><a href="namespaces.html">Namespaces</a></li>
          </ol>
          <ol class="m-col-t-6 m-col-m-none" start="3">
            <li><a href="annotated.html">Classes</a></li>
            <li><a href="files.html">Files</a></li>
            <li class="m-show-m"><a href="#search" class="m-doc-search-icon" title="Search" onclick="return showSearch()"><svg style="height: 0.9rem;" viewBox="0 0 16 16">
              <use href="#m-doc-search-icon-path" />
            </svg></a></li>
          </ol>
        </div>
      </div>
    </div>
  </div>
</nav></header>
<main><article>
  <div class="m-container m-container-inflatable">
    <div class="m-row">
      <div class="m-col-l-10 m-push-l-1">
        <h1>
          <div class="m-doc-template">template&lt;typename P&gt;</div>
          <span class="m-breadcrumb"><a href="namespacetf.html">tf</a>::<wbr/></span>ScalablePipeline <span class="m-thin">class</span>
        </h1>
        <p>class to create a scalable pipeline object</p>
        <table class="m-table m-fullwidth m-flat">
          <thead>
            <tr><th colspan="2">Template parameters</th></tr>
          </thead>
          <tbody>
            <tr>
              <td style="width: 1%">P</td>
              <td>type of the iterator to a range of pipes</td>
            </tr>
          </tbody>
        </table>
        <nav class="m-block m-default">
          <h3>Contents</h3>
          <ul>
            <li>
              Reference
              <ul>
                <li><a href="#pub-types">Public types</a></li>
                <li><a href="#typeless-methods">Constructors, destructors, conversion operators</a></li>
                <li><a href="#pub-methods">Public functions</a></li>
              </ul>
            </li>
          </ul>
        </nav>
<p>A scalable pipeline is a composable graph object for users to create a <em>pipeline scheduling framework</em> using a module task in a taskflow. Unlike <a href="classtf_1_1Pipeline.html" class="m-doc">tf::<wbr />Pipeline</a> that instantiates all pipes upon the construction time, <a href="classtf_1_1ScalablePipeline.html" class="m-doc">tf::<wbr />ScalablePipeline</a> allows variable assignments of pipes using range iterators. Users can also reset a scalable pipeline to a different range of pipes between runs. The following code creates a scalable pipeline of four parallel lines to schedule tokens through three serial pipes in a custom storage, then resetting the pipeline to a new range of five serial pipes:</p><pre class="m-code"><span class="n">tf</span><span class="o">::</span><span class="n">Taskflow</span><span class="w"> </span><span class="nf">taskflow</span><span class="p">(</span><span class="s">&quot;pipeline&quot;</span><span class="p">);</span><span class="w"></span>
<span class="n">tf</span><span class="o">::</span><span class="n">Executor</span><span class="w"> </span><span class="n">executor</span><span class="p">;</span><span class="w"></span>

<span class="k">const</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">num_lines</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">4</span><span class="p">;</span><span class="w"></span>

<span class="c1">// create data storage</span>
<span class="n">std</span><span class="o">::</span><span class="n">array</span><span class="o">&lt;</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">num_lines</span><span class="o">&gt;</span><span class="w"> </span><span class="n">buffer</span><span class="p">;</span><span class="w"></span>

<span class="c1">// define the pipe callable</span>
<span class="k">auto</span><span class="w"> </span><span class="n">pipe_callable</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">[</span><span class="o">&amp;</span><span class="n">buffer</span><span class="p">]</span><span class="w"> </span><span class="p">(</span><span class="n">tf</span><span class="o">::</span><span class="n">Pipeflow</span><span class="o">&amp;</span><span class="w"> </span><span class="n">pf</span><span class="p">)</span><span class="w"> </span><span class="k">mutable</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">  </span><span class="k">switch</span><span class="p">(</span><span class="n">pf</span><span class="p">.</span><span class="n">pipe</span><span class="p">())</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">    </span><span class="c1">// first stage generates only 5 scheduling tokens and saves the</span>
<span class="w">    </span><span class="c1">// token number into the buffer.</span>
<span class="w">    </span><span class="k">case</span><span class="w"> </span><span class="mi">0</span><span class="o">:</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">      </span><span class="k">if</span><span class="p">(</span><span class="n">pf</span><span class="p">.</span><span class="n">token</span><span class="p">()</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">5</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">        </span><span class="n">pf</span><span class="p">.</span><span class="n">stop</span><span class="p">();</span><span class="w"></span>
<span class="w">      </span><span class="p">}</span><span class="w"></span>
<span class="w">      </span><span class="k">else</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">        </span><span class="n">printf</span><span class="p">(</span><span class="s">&quot;stage 1: input token = %zu</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">pf</span><span class="p">.</span><span class="n">token</span><span class="p">());</span><span class="w"></span>
<span class="w">        </span><span class="n">buffer</span><span class="p">[</span><span class="n">pf</span><span class="p">.</span><span class="n">line</span><span class="p">()]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pf</span><span class="p">.</span><span class="n">token</span><span class="p">();</span><span class="w"></span>
<span class="w">      </span><span class="p">}</span><span class="w"></span>
<span class="w">      </span><span class="k">return</span><span class="p">;</span><span class="w"></span>
<span class="w">    </span><span class="p">}</span><span class="w"></span>
<span class="w">    </span><span class="k">break</span><span class="p">;</span><span class="w"></span>

<span class="w">    </span><span class="c1">// other stages propagate the previous result to this pipe and</span>
<span class="w">    </span><span class="c1">// increment it by one</span>
<span class="w">    </span><span class="k">default</span><span class="o">:</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">      </span><span class="n">printf</span><span class="p">(</span><span class="w"></span>
<span class="w">        </span><span class="s">&quot;stage %zu: input buffer[%zu] = %d</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">pf</span><span class="p">.</span><span class="n">pipe</span><span class="p">(),</span><span class="w"> </span><span class="n">pf</span><span class="p">.</span><span class="n">line</span><span class="p">(),</span><span class="w"> </span><span class="n">buffer</span><span class="p">[</span><span class="n">pf</span><span class="p">.</span><span class="n">line</span><span class="p">()]</span><span class="w"></span>
<span class="w">      </span><span class="p">);</span><span class="w"></span>
<span class="w">      </span><span class="n">buffer</span><span class="p">[</span><span class="n">pf</span><span class="p">.</span><span class="n">line</span><span class="p">()]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">buffer</span><span class="p">[</span><span class="n">pf</span><span class="p">.</span><span class="n">line</span><span class="p">()]</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"></span>
<span class="w">    </span><span class="p">}</span><span class="w"></span>
<span class="w">    </span><span class="k">break</span><span class="p">;</span><span class="w"></span>
<span class="w">  </span><span class="p">}</span><span class="w"></span>
<span class="p">};</span><span class="w"></span>

<span class="c1">// create a vector of three pipes</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o">&lt;</span><span class="w"> </span><span class="n">tf</span><span class="o">::</span><span class="n">Pipe</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="n">function</span><span class="o">&lt;</span><span class="kt">void</span><span class="p">(</span><span class="n">tf</span><span class="o">::</span><span class="n">Pipeflow</span><span class="o">&amp;</span><span class="p">)</span><span class="o">&gt;&gt;</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">pipes</span><span class="p">;</span><span class="w"></span>

<span class="k">for</span><span class="p">(</span><span class="kt">size_t</span><span class="w"> </span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">&lt;</span><span class="mi">3</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">  </span><span class="n">pipes</span><span class="p">.</span><span class="n">emplace_back</span><span class="p">(</span><span class="n">tf</span><span class="o">::</span><span class="n">PipeType</span><span class="o">::</span><span class="n">SERIAL</span><span class="p">,</span><span class="w"> </span><span class="n">pipe_callable</span><span class="p">);</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>

<span class="c1">// create a pipeline of four parallel lines based on the given vector of pipes</span>
<span class="n">tf</span><span class="o">::</span><span class="n">ScalablePipeline</span><span class="w"> </span><span class="n">pl</span><span class="p">(</span><span class="n">num_lines</span><span class="p">,</span><span class="w"> </span><span class="n">pipes</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span><span class="w"> </span><span class="n">pipes</span><span class="p">.</span><span class="n">end</span><span class="p">());</span><span class="w"></span>

<span class="c1">// build the pipeline graph using composition</span>
<span class="n">tf</span><span class="o">::</span><span class="n">Task</span><span class="w"> </span><span class="n">init</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">taskflow</span><span class="p">.</span><span class="n">emplace</span><span class="p">([](){</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;ready</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">;</span><span class="w"> </span><span class="p">})</span><span class="w"></span>
<span class="w">                        </span><span class="p">.</span><span class="n">name</span><span class="p">(</span><span class="s">&quot;starting pipeline&quot;</span><span class="p">);</span><span class="w"></span>
<span class="n">tf</span><span class="o">::</span><span class="n">Task</span><span class="w"> </span><span class="n">task</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">taskflow</span><span class="p">.</span><span class="n">composed_of</span><span class="p">(</span><span class="n">pl</span><span class="p">)</span><span class="w"></span>
<span class="w">                        </span><span class="p">.</span><span class="n">name</span><span class="p">(</span><span class="s">&quot;pipeline&quot;</span><span class="p">);</span><span class="w"></span>
<span class="n">tf</span><span class="o">::</span><span class="n">Task</span><span class="w"> </span><span class="n">stop</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">taskflow</span><span class="p">.</span><span class="n">emplace</span><span class="p">([](){</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">&quot;stopped</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">;</span><span class="w"> </span><span class="p">})</span><span class="w"></span>
<span class="w">                        </span><span class="p">.</span><span class="n">name</span><span class="p">(</span><span class="s">&quot;pipeline stopped&quot;</span><span class="p">);</span><span class="w"></span>

<span class="c1">// create task dependency</span>
<span class="n">init</span><span class="p">.</span><span class="n">precede</span><span class="p">(</span><span class="n">task</span><span class="p">);</span><span class="w"></span>
<span class="n">task</span><span class="p">.</span><span class="n">precede</span><span class="p">(</span><span class="n">stop</span><span class="p">);</span><span class="w"></span>

<span class="c1">// dump the pipeline graph structure (with composition)</span>
<span class="n">taskflow</span><span class="p">.</span><span class="n">dump</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="p">);</span><span class="w"></span>

<span class="c1">// run the pipeline</span>
<span class="n">executor</span><span class="p">.</span><span class="n">run</span><span class="p">(</span><span class="n">taskflow</span><span class="p">).</span><span class="n">wait</span><span class="p">();</span><span class="w"></span>

<span class="c1">// reset the pipeline to a new range of five pipes and starts from</span>
<span class="c1">// the initial state (i.e., token counts from zero)</span>
<span class="k">for</span><span class="p">(</span><span class="kt">size_t</span><span class="w"> </span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">&lt;</span><span class="mi">2</span><span class="p">;</span><span class="w"> </span><span class="n">i</span><span class="o">++</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w">  </span><span class="n">pipes</span><span class="p">.</span><span class="n">emplace_back</span><span class="p">(</span><span class="n">tf</span><span class="o">::</span><span class="n">PipeType</span><span class="o">::</span><span class="n">SERIAL</span><span class="p">,</span><span class="w"> </span><span class="n">pipe_callable</span><span class="p">);</span><span class="w"></span>
<span class="p">}</span><span class="w"></span>
<span class="n">pl</span><span class="p">.</span><span class="n">reset</span><span class="p">(</span><span class="n">pipes</span><span class="p">.</span><span class="n">begin</span><span class="p">(),</span><span class="w"> </span><span class="n">pipes</span><span class="p">.</span><span class="n">end</span><span class="p">());</span><span class="w"></span>

<span class="n">executor</span><span class="p">.</span><span class="n">run</span><span class="p">(</span><span class="n">taskflow</span><span class="p">).</span><span class="n">wait</span><span class="p">();</span><span class="w"></span></pre><p>The above example creates a pipeline graph that schedules five tokens over four parallel lines in a circular fashion, first going through three serial pipes and then five serial pipes:</p><pre class="m-console"><span class="gp"># </span>initial construction of three serial pipes
<span class="go">o -&gt; o -&gt; o</span>
<span class="go">|    |    |</span>
<span class="go">v    v    v</span>
<span class="go">o -&gt; o -&gt; o</span>
<span class="go">|    |    |</span>
<span class="go">v    v    v</span>
<span class="go">o -&gt; o -&gt; o</span>
<span class="go">|    |    |</span>
<span class="go">v    v    v</span>
<span class="go">o -&gt; o -&gt; o</span>

<span class="gp"># </span>resetting to a new range of five serial pipes
<span class="go">o -&gt; o -&gt; o -&gt; o -&gt; o</span>
<span class="go">|    |    |    |    |</span>
<span class="go">v    v    v    v    v</span>
<span class="go">o -&gt; o -&gt; o -&gt; o -&gt; o</span>
<span class="go">|    |    |    |    |</span>
<span class="go">v    v    v    v    v</span>
<span class="go">o -&gt; o -&gt; o -&gt; o -&gt; o</span>
<span class="go">|    |    |    |    |</span>
<span class="go">v    v    v    v    v</span>
<span class="go">o -&gt; o -&gt; o -&gt; o -&gt; o</span></pre><p>Each pipe has the same type of <code>tf::Pipe&lt;std::function&lt;void(tf::Pipeflow&amp;)&gt;&gt;</code> and is kept in a vector that is amenable to change. We construct the scalable pipeline using two range iterators pointing to the beginning and the end of the vector. At each pipe stage, the program propagates the result to the next pipe by adding one to the result stored in a custom data storage, <code>buffer</code>. The pipeline scheduler will generate five scheduling tokens and then stop.</p><p>A scalable pipeline is move-only.</p>
        <section id="pub-types">
          <h2><a href="#pub-types">Public types</a></h2>
          <dl class="m-doc">
            <dt id="af06cc645f8a7c4797ca53e274b0c7547">
              using <a href="#af06cc645f8a7c4797ca53e274b0c7547" class="m-doc-self">pipe_t</a> = typename <a href="http://en.cppreference.com/w/cpp/iterator/iterator_traits.html" class="m-doc-external">std::<wbr />iterator_traits</a>&lt;P&gt;::value_type
            </dt>
            <dd>pipe type</dd>
          </dl>
        </section>
        <section id="typeless-methods">
          <h2><a href="#typeless-methods">Constructors, destructors, conversion operators</a></h2>
          <dl class="m-doc">
            <dt id="a26f5e7e768b77f9e95100c5d6467db71">
              <span class="m-doc-wrap-bumper"><a href="#a26f5e7e768b77f9e95100c5d6467db71" class="m-doc-self">ScalablePipeline</a>(</span><span class="m-doc-wrap">) <span class="m-label m-flat m-info">defaulted</span></span>
            </dt>
            <dd>default constructor</dd>
            <dt>
              <span class="m-doc-wrap-bumper"><a href="#a0f99aa297a26b97d549b62722d91e8ca" class="m-doc">ScalablePipeline</a>(</span><span class="m-doc-wrap">size_t num_lines)</span>
            </dt>
            <dd>constructs an empty scalable pipeline object</dd>
            <dt>
              <span class="m-doc-wrap-bumper"><a href="#a884818f628bbd4ab876d566b1d2d62dc" class="m-doc">ScalablePipeline</a>(</span><span class="m-doc-wrap">size_t num_lines,
              P first,
              P last)</span>
            </dt>
            <dd>constructs a scalable pipeline object</dd>
            <dt id="a1a8898df4d2224d5f8bd2f3ad14c0ab9">
              <span class="m-doc-wrap-bumper"><a href="#a1a8898df4d2224d5f8bd2f3ad14c0ab9" class="m-doc-self">ScalablePipeline</a>(</span><span class="m-doc-wrap">const <a href="classtf_1_1ScalablePipeline.html" class="m-doc">ScalablePipeline</a>&amp;) <span class="m-label m-flat m-danger">deleted</span></span>
            </dt>
            <dd>disabled copy constructor</dd>
            <dt>
              <span class="m-doc-wrap-bumper"><a href="#a1ab74fa599b0f1489df398cf039b73e5" class="m-doc">ScalablePipeline</a>(</span><span class="m-doc-wrap"><a href="classtf_1_1ScalablePipeline.html" class="m-doc">ScalablePipeline</a>&amp;&amp; rhs)</span>
            </dt>
            <dd>move constructor</dd>
          </dl>
        </section>
        <section id="pub-methods">
          <h2><a href="#pub-methods">Public functions</a></h2>
          <dl class="m-doc">
            <dt id="a317702ac0bc8c860c68a1f19e57274c5">
              <span class="m-doc-wrap-bumper">auto <a href="#a317702ac0bc8c860c68a1f19e57274c5" class="m-doc-self">operator=</a>(</span><span class="m-doc-wrap">const <a href="classtf_1_1ScalablePipeline.html" class="m-doc">ScalablePipeline</a>&amp;) -&gt; <a href="classtf_1_1ScalablePipeline.html" class="m-doc">ScalablePipeline</a>&amp; <span class="m-label m-flat m-danger">deleted</span></span>
            </dt>
            <dd>disabled copy assignment operator</dd>
            <dt>
              <span class="m-doc-wrap-bumper">auto <a href="#a72a123bf432763ce095c201c2655051c" class="m-doc">operator=</a>(</span><span class="m-doc-wrap"><a href="classtf_1_1ScalablePipeline.html" class="m-doc">ScalablePipeline</a>&amp;&amp; rhs) -&gt; <a href="classtf_1_1ScalablePipeline.html" class="m-doc">ScalablePipeline</a>&amp;</span>
            </dt>
            <dd>move constructor</dd>
            <dt>
              <span class="m-doc-wrap-bumper">auto <a href="#a5a4dd65638e8e06e35cb4c5792d044cc" class="m-doc">num_lines</a>(</span><span class="m-doc-wrap">) const -&gt; size_t <span class="m-label m-flat m-success">noexcept</span></span>
            </dt>
            <dd>queries the number of parallel lines</dd>
            <dt>
              <span class="m-doc-wrap-bumper">auto <a href="#a70c49f5219847681133d2a226c804da1" class="m-doc">num_pipes</a>(</span><span class="m-doc-wrap">) const -&gt; size_t <span class="m-label m-flat m-success">noexcept</span></span>
            </dt>
            <dd>queries the number of pipes</dd>
            <dt>
              <span class="m-doc-wrap-bumper">void <a href="#a940a8de7b53ac5cbd59c55091d88c88f" class="m-doc">reset</a>(</span><span class="m-doc-wrap">)</span>
            </dt>
            <dd>resets the pipeline</dd>
            <dt>
              <span class="m-doc-wrap-bumper">void <a href="#ad8886d402568a9980952fa4ab59adcab" class="m-doc">reset</a>(</span><span class="m-doc-wrap">P first,
              P last)</span>
            </dt>
            <dd>resets the pipeline with a new range of pipes</dd>
            <dt>
              <span class="m-doc-wrap-bumper">void <a href="#a8165894518d642ceaa0141e2a66d365a" class="m-doc">reset</a>(</span><span class="m-doc-wrap">size_t num_lines,
              P first,
              P last)</span>
            </dt>
            <dd>resets the pipeline to a new line number and a new range of pipes</dd>
            <dt>
              <span class="m-doc-wrap-bumper">auto <a href="#a693a2ea53cfac9c0b220d5b3a28e6313" class="m-doc">num_tokens</a>(</span><span class="m-doc-wrap">) const -&gt; size_t <span class="m-label m-flat m-success">noexcept</span></span>
            </dt>
            <dd>queries the number of generated tokens in the pipeline</dd>
            <dt>
              <span class="m-doc-wrap-bumper">auto <a href="#a2f45a4cb7116fbe9bbc54305f13c52a8" class="m-doc">graph</a>(</span><span class="m-doc-wrap">) -&gt; <a href="classtf_1_1Graph.html" class="m-doc">Graph</a>&amp;</span>
            </dt>
            <dd>obtains the graph object associated with the pipeline construct</dd>
          </dl>
        </section>
        <section>
          <h2>Function documentation</h2>
          <section class="m-doc-details" id="a0f99aa297a26b97d549b62722d91e8ca"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper"> tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#a0f99aa297a26b97d549b62722d91e8ca" class="m-doc-self">ScalablePipeline</a>(</span><span class="m-doc-wrap">size_t num_lines)</span></span>
            </h3>
            <p>constructs an empty scalable pipeline object</p>
            <table class="m-table m-fullwidth m-flat">
              <thead>
                <tr><th colspan="2">Parameters</th></tr>
              </thead>
              <tbody>
                <tr>
                  <td style="width: 1%">num_lines</td>
                  <td>the number of parallel lines</td>
                </tr>
              </tbody>
            </table>
<p>An empty scalable pipeline does not have any pipes. The pipeline needs to be reset to a valid range of pipes before running.</p>
          </div></section>
          <section class="m-doc-details" id="a884818f628bbd4ab876d566b1d2d62dc"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper"> tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#a884818f628bbd4ab876d566b1d2d62dc" class="m-doc-self">ScalablePipeline</a>(</span><span class="m-doc-wrap">size_t num_lines,
              P first,
              P last)</span></span>
            </h3>
            <p>constructs a scalable pipeline object</p>
            <table class="m-table m-fullwidth m-flat">
              <thead>
                <tr><th colspan="2">Parameters</th></tr>
              </thead>
              <tbody>
                <tr>
                  <td style="width: 1%">num_lines</td>
                  <td>the number of parallel lines</td>
                </tr>
                <tr>
                  <td>first</td>
                  <td>iterator to the beginning of the range</td>
                </tr>
                <tr>
                  <td>last</td>
                  <td>iterator to the end of the range</td>
                </tr>
              </tbody>
            </table>
<p>Constructs a pipeline from the given range of pipes specified in <code>[first, last)</code> using <code>num_lines</code> parallel lines. The first pipe must define a serial direction (<a href="namespacetf.html#abb7a11e41fd457f69e7ff45d4c769564a7b804a28d6154ab8007287532037f1d0" class="m-doc">tf::<wbr />PipeType::<wbr />SERIAL</a>) or an exception will be thrown.</p><p>Internally, the scalable pipeline copies the iterators from the specified range. Those pipe callables pointed to by these iterators must remain valid during the execution of the pipeline.</p>
          </div></section>
          <section class="m-doc-details" id="a1ab74fa599b0f1489df398cf039b73e5"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper"> tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#a1ab74fa599b0f1489df398cf039b73e5" class="m-doc-self">ScalablePipeline</a>(</span><span class="m-doc-wrap"><a href="classtf_1_1ScalablePipeline.html" class="m-doc">ScalablePipeline</a>&amp;&amp; rhs)</span></span>
            </h3>
            <p>move constructor</p>
<p>Constructs a pipeline from the given <code>rhs</code> using move semantics (i.e. the data in <code>rhs</code> is moved into this pipeline). After the move, <code>rhs</code> is in a state as if it is just constructed. The behavior is undefined if <code>rhs</code> is running during the move.</p>
          </div></section>
          <section class="m-doc-details" id="a72a123bf432763ce095c201c2655051c"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper"><a href="classtf_1_1ScalablePipeline.html" class="m-doc">ScalablePipeline</a>&amp; tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#a72a123bf432763ce095c201c2655051c" class="m-doc-self">operator=</a>(</span><span class="m-doc-wrap"><a href="classtf_1_1ScalablePipeline.html" class="m-doc">ScalablePipeline</a>&amp;&amp; rhs)</span></span>
            </h3>
            <p>move constructor</p>
<p>Replaces the contents with those of <code>rhs</code> using move semantics (i.e. the data in <code>rhs</code> is moved into this pipeline). After the move, <code>rhs</code> is in a state as if it is just constructed. The behavior is undefined if <code>rhs</code> is running during the move.</p>
          </div></section>
          <section class="m-doc-details" id="a5a4dd65638e8e06e35cb4c5792d044cc"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper">size_t tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#a5a4dd65638e8e06e35cb4c5792d044cc" class="m-doc-self">num_lines</a>(</span><span class="m-doc-wrap">) const <span class="m-label m-success">noexcept</span></span></span>
            </h3>
            <p>queries the number of parallel lines</p>
<p>The function returns the number of parallel lines given by the user upon the construction of the pipeline. The number of lines represents the maximum parallelism this pipeline can achieve.</p>
          </div></section>
          <section class="m-doc-details" id="a70c49f5219847681133d2a226c804da1"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper">size_t tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#a70c49f5219847681133d2a226c804da1" class="m-doc-self">num_pipes</a>(</span><span class="m-doc-wrap">) const <span class="m-label m-success">noexcept</span></span></span>
            </h3>
            <p>queries the number of pipes</p>
<p>The Function returns the number of pipes given by the user upon the construction of the pipeline.</p>
          </div></section>
          <section class="m-doc-details" id="a940a8de7b53ac5cbd59c55091d88c88f"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper">void tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#a940a8de7b53ac5cbd59c55091d88c88f" class="m-doc-self">reset</a>(</span><span class="m-doc-wrap">)</span></span>
            </h3>
            <p>resets the pipeline</p>
<p>Resets the pipeline to the initial state. After resetting a pipeline, its token identifier will start from zero.</p>
          </div></section>
          <section class="m-doc-details" id="ad8886d402568a9980952fa4ab59adcab"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper">void tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#ad8886d402568a9980952fa4ab59adcab" class="m-doc-self">reset</a>(</span><span class="m-doc-wrap">P first,
              P last)</span></span>
            </h3>
            <p>resets the pipeline with a new range of pipes</p>
            <table class="m-table m-fullwidth m-flat">
              <thead>
                <tr><th colspan="2">Parameters</th></tr>
              </thead>
              <tbody>
                <tr>
                  <td style="width: 1%">first</td>
                  <td>iterator to the beginning of the range</td>
                </tr>
                <tr>
                  <td>last</td>
                  <td>iterator to the end of the range</td>
                </tr>
              </tbody>
            </table>
<p>The member function assigns the pipeline to a new range of pipes specified in <code>[first, last)</code> and resets the pipeline to the initial state. After resetting a pipeline, its token identifier will start from zero.</p><p>Internally, the scalable pipeline copies the iterators from the specified range. Those pipe callables pointed to by these iterators must remain valid during the execution of the pipeline.</p>
          </div></section>
          <section class="m-doc-details" id="a8165894518d642ceaa0141e2a66d365a"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper">void tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#a8165894518d642ceaa0141e2a66d365a" class="m-doc-self">reset</a>(</span><span class="m-doc-wrap">size_t num_lines,
              P first,
              P last)</span></span>
            </h3>
            <p>resets the pipeline to a new line number and a new range of pipes</p>
            <table class="m-table m-fullwidth m-flat">
              <thead>
                <tr><th colspan="2">Parameters</th></tr>
              </thead>
              <tbody>
                <tr>
                  <td style="width: 1%">num_lines</td>
                  <td>number of parallel lines</td>
                </tr>
                <tr>
                  <td>first</td>
                  <td>iterator to the beginning of the range</td>
                </tr>
                <tr>
                  <td>last</td>
                  <td>iterator to the end of the range</td>
                </tr>
              </tbody>
            </table>
<p>The member function resets the pipeline to a new number of parallel lines and a new range of pipes specified in <code>[first, last)</code>, as if the pipeline is just constructed. After resetting a pipeline, its token identifier will start from zero.</p><p>Internally, the scalable pipeline copies the iterators from the specified range. Those pipe callables pointed to by these iterators must remain valid during the execution of the pipeline.</p>
          </div></section>
          <section class="m-doc-details" id="a693a2ea53cfac9c0b220d5b3a28e6313"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper">size_t tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#a693a2ea53cfac9c0b220d5b3a28e6313" class="m-doc-self">num_tokens</a>(</span><span class="m-doc-wrap">) const <span class="m-label m-success">noexcept</span></span></span>
            </h3>
            <p>queries the number of generated tokens in the pipeline</p>
<p>The number represents the total scheduling tokens that has been generated by the pipeline so far.</p>
          </div></section>
          <section class="m-doc-details" id="a2f45a4cb7116fbe9bbc54305f13c52a8"><div>
            <h3>
              <div class="m-doc-template">
                template&lt;typename P&gt;
              </div>
              <span class="m-doc-wrap-bumper"><a href="classtf_1_1Graph.html" class="m-doc">Graph</a>&amp; tf::<wbr />ScalablePipeline&lt;P&gt;::<wbr /></span><span class="m-doc-wrap"><span class="m-doc-wrap-bumper"><a href="#a2f45a4cb7116fbe9bbc54305f13c52a8" class="m-doc-self">graph</a>(</span><span class="m-doc-wrap">)</span></span>
            </h3>
            <p>obtains the graph object associated with the pipeline construct</p>
<p>This method is primarily used as an opaque data structure for creating a module task of the this pipeline.</p>
          </div></section>
        </section>
      </div>
    </div>
  </div>
</article></main>
<div class="m-doc-search" id="search">
  <a href="#!" onclick="return hideSearch()"></a>
  <div class="m-container">
    <div class="m-row">
      <div class="m-col-m-8 m-push-m-2">
        <div class="m-doc-search-header m-text m-small">
          <div><span class="m-label m-default">Tab</span> / <span class="m-label m-default">T</span> to search, <span class="m-label m-default">Esc</span> to close</div>
          <div id="search-symbolcount">&hellip;</div>
        </div>
        <div class="m-doc-search-content">
          <form>
            <input type="search" name="q" id="search-input" placeholder="Loading &hellip;" disabled="disabled" autofocus="autofocus" autocomplete="off" spellcheck="false" />
          </form>
          <noscript class="m-text m-danger m-text-center">Unlike everything else in the docs, the search functionality <em>requires</em> JavaScript.</noscript>
          <div id="search-help" class="m-text m-dim m-text-center">
            <p class="m-noindent">Search for symbols, directories, files, pages or
            modules. You can omit any prefix from the symbol or file path; adding a
            <code>:</code> or <code>/</code> suffix lists all members of given symbol or
            directory.</p>
            <p class="m-noindent">Use <span class="m-label m-dim">&darr;</span>
            / <span class="m-label m-dim">&uarr;</span> to navigate through the list,
            <span class="m-label m-dim">Enter</span> to go.
            <span class="m-label m-dim">Tab</span> autocompletes common prefix, you can
            copy a link to the result using <span class="m-label m-dim">⌘</span>
            <span class="m-label m-dim">L</span> while <span class="m-label m-dim">⌘</span>
            <span class="m-label m-dim">M</span> produces a Markdown link.</p>
          </div>
          <div id="search-notfound" class="m-text m-warning m-text-center">Sorry, nothing was found.</div>
          <ul id="search-results"></ul>
        </div>
      </div>
    </div>
  </div>
</div>
<script src="search-v2.js"></script>
<script src="searchdata-v2.js" async="async"></script>
<footer><nav>
  <div class="m-container">
    <div class="m-row">
      <div class="m-col-l-10 m-push-l-1">
        <p>Taskflow handbook is part of the <a href="https://taskflow.github.io">Taskflow project</a>, copyright © <a href="https://tsung-wei-huang.github.io/">Dr. Tsung-Wei Huang</a>, 2018&ndash;2023.<br />Generated by <a href="https://doxygen.org/">Doxygen</a> 1.9.1 and <a href="https://mcss.mosra.cz/">m.css</a>.</p>
      </div>
    </div>
  </div>
</nav></footer>
</body>
</html>
